home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / window.c < prev   
Encoding:
C/C++ Source or Header  |  1995-01-26  |  15.8 KB  |  571 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    newwin
  25. #undef    delwin
  26. #undef    mvwin
  27. #undef    subwin
  28. #undef    derwin
  29. #undef    mvderwin
  30. #undef    dupwin
  31. #undef    wsyncup
  32. #undef    syncok
  33. #undef    wcursyncup
  34. #undef    wsyncdown
  35. #undef    resize_window
  36.  
  37. /* undefine any macros for functions called by this module if in debug mode */
  38. #ifdef PDCDEBUG
  39. #  undef    touchwin
  40. #  undef    wmove
  41. #  undef    overwrite
  42. #  undef    wmove
  43. #  undef    wclrtobot
  44. #endif
  45.  
  46. #ifdef PDCDEBUG
  47. char *rcsid_window  = "$Id$";
  48. #endif
  49.  
  50. /*man-start*********************************************************************
  51.  
  52.   Name:                                                        window
  53.  
  54.   Synopsis:
  55.       WINDOW *newwin(int nlines, int ncols, int begy, int begx);
  56.       int delwin(WINDOW *win);
  57.       int mvwin(WINDOW *win, int y, int x);
  58.       WINDOW *subwin(WINDOW* orig,int nlines,int ncols,
  59.               int begin_y,int begin_x);
  60.       WINDOW *derwin(WINDOW* orig,int nlines,int ncols,
  61.               int begin_y,int begin_x);
  62.       int mvderwin(WINDOW *win, int par_y, int par_x);
  63.       int dupwin(WINDOW *win);
  64.   ***    void wsyncup(WINDOW *win);
  65.   ***    int syncok(WINDOW *win, bool bf);
  66.   ***    void wcursyncup(WINDOW *win);
  67.   ***    void wsyncdown(WINDOW *win);
  68.  
  69.       WINDOW *resize_window(WINDOW *w, int lins, int cols);
  70.  
  71.   X/Open Description:
  72.      newwin() creates a new window with the given number of lines, 
  73.      nlines and columns, ncols. The upper left corner of the window is 
  74.      at line begy, column begx. If either nlines or ncols is zero,
  75.      they will be defaulted to LINES - begy and COLS - begx. A
  76.      new full-screen window is created by calling newwin(0, 0, 0, 0).
  77.  
  78.      delwin() deletes the named window, freeing all memory associated 
  79.      with it. In the case of overlapping windows, subwindows should be 
  80.      deleted before the main window.
  81.  
  82.      mvwin() moves the window so that the upper left-hand corner is at
  83.      position (y,x). If the move would cause the window to be off the
  84.      screen, it is an error and the window is not moved. Moving subwindows
  85.      is allowed, but should be avoided. (I don't know why ?).
  86.  
  87.      subwin() creates a new sub-window within a window.  The
  88.      dimensions of the sub-window are nlines lines and ncols
  89.      columns.  The sub-window is at position (begin_y, begin_x) on
  90.      the screen.  This position is relative to the screen, and not
  91.      to the window orig.
  92.      The sub-window is made in the middle of the window orig, so
  93.      that changes made to either window will affect both.  When
  94.      using this routine, it will often be necessary to call
  95.      touchwin() before calling wrefresh().
  96.  
  97.      derwin() is the same as subwin(), except that begin_y and
  98.      begin_x are relative to the origin of the window orig rather than
  99.      the screen.  There is no difference between subwindows and derived
  100.      windows.
  101.  
  102.      mvderwin() moves a derived window (or subwindow) inside its
  103.      parent window.  The screen-relative parameters of the window are not
  104.      changed.  This routine is used to dispay different parts of the parent
  105.      window at the same physical position on the screen.
  106.  
  107.      dupwin() creates an exact duplicate of the window win.
  108.  
  109.   PDCurses Description:
  110.      resize_window() does necessary initializations for the PDCurses 
  111.      package when doing screen size changes. The user is responsible for
  112.      deleting and/or resizing windows after this call is made.
  113.  
  114.      See the call PDC_resize_win().
  115.  
  116.      WARNING: This routine deallocated the existing stdscr, curscr
  117.      and modifies LINES, COLS and other internal PDCurses
  118.      variables.
  119.  
  120.   X/Open Return Value:
  121.      All functions return OK on success and ERR on error.
  122.  
  123.   X/Open Errors:
  124.      No errors are defined for this function.
  125.  
  126.   PDCurses Errors:
  127.      It is an error to call resize_window()function before calling initscr().
  128.      Also, an error will be generated if we fail to create a newly
  129.      sized replacement window for curscr, or stdscr.
  130.      This will typically happen when increasing the window size.
  131.  
  132.      NOTE:  If this happens, the previously successfully allocated
  133.      windows are left alone.  i.e. The resize is NOT cancelled for
  134.      those windows.
  135.  
  136.   Portability                             X/Open    BSD    SYS V
  137.                                           Dec '88
  138.       newwin                                Y        Y       Y
  139.       delwin                                Y        Y       Y
  140.       mvwin                                 Y        Y       Y
  141.       subwin                                Y        Y       Y
  142.       derwin                                Y        -       Y
  143.       mvderwin                              Y        -       Y
  144.       dupwin                                -        -      4.0
  145.       wsyncup                               -        -      4.0
  146.       syncok                                -        -      4.0
  147.       wcursyncup                            -        -      4.0
  148.       wsyncdown                             -        -      4.0
  149.       resize_window                         -        -       -
  150.  
  151. **man-end**********************************************************************/
  152.  
  153. /***********************************************************************/
  154. WINDOW*    newwin(int nlines, int ncols, int begy, int begx)
  155. /***********************************************************************/
  156. {
  157. extern    void*    (*mallc)( size_t );
  158. extern    void*    (*callc)( size_t, size_t );
  159. extern    void    (*fre)( void* );
  160.  
  161.     WINDOW*    win;
  162.     chtype*    ptr;
  163.     int    i;
  164.     int    j;
  165.  
  166. #ifdef PDCDEBUG
  167.     if (trace_on) PDC_debug("newwin() - called:lines=%d cols=%d begy=%d begx=%d\n",nlines,ncols,begy,begx);
  168. #endif
  169.  
  170.     if (nlines == 0)    nlines = LINES - begy;
  171.     if (ncols  == 0)    ncols  = COLS  - begx;
  172.  
  173.     if ((win = PDC_makenew(nlines, ncols, begy, begx)) == (WINDOW *) NULL)
  174.         return( (WINDOW *)NULL );
  175.  
  176.     for (i = 0; i < nlines; i++)
  177.     {
  178.         /*
  179.          * make and clear the lines
  180.          */
  181.         if ((win->_y[i] = (*callc)(ncols, sizeof(chtype))) == NULL)
  182.         {
  183.             for (j = 0; j < i; j++)
  184.             {
  185.                 /*
  186.                  * if error, free all the data
  187.                  */
  188.                 (*fre)(win->_y[j]);
  189.             }
  190.             (*fre)(win->_firstch);
  191.             (*fre)(win->_lastch);
  192.             (*fre)(win->_y);
  193.             (*fre)(win);
  194.             return( (WINDOW *)NULL );
  195.         }
  196.         else
  197.         {
  198.             for (ptr = win->_y[i];
  199.                  ptr < win->_y[i] + ncols;)
  200.             {
  201.                 /*
  202.                  * Retain the original screen attributes...
  203.                  */
  204.                 *ptr++ = _cursvar.blank;
  205.             }
  206.         }
  207.     }
  208. #ifdef UNIX
  209.     PDC_gotoxy(begy, begx);
  210. #endif
  211.     return( win );
  212. }
  213. /***********************************************************************/
  214. int    delwin(WINDOW *win)
  215. /***********************************************************************/
  216. {
  217. extern    void    (*fre)( void* );
  218.     int    i;
  219.  
  220. #ifdef PDCDEBUG
  221.     if (trace_on) PDC_debug("delwin() - called\n");
  222. #endif
  223.  
  224.  
  225.     if (win == (WINDOW *)NULL)
  226.         return( ERR );
  227.  
  228. #ifdef    REGISTERWINDOWS
  229.     _rmwin(win);        /* Remove from the visible windows list... */
  230. #endif
  231.  
  232.     /*
  233.      * FYI:  Subwindow's use 'parent's' lines
  234.      */
  235.     if (!(win->_flags & _SUBWIN)
  236.     &&  !(win->_flags & _SUBPAD))
  237.     {
  238.         for (i = 0; i < win->_pmaxy && win->_y[i]; i++)
  239.         {
  240.             if (win->_y[i] != NULL)
  241.                 (*fre)(win->_y[i]);
  242.         }
  243.     }
  244.     (*fre)(win->_firstch);
  245.     (*fre)(win->_lastch);
  246.     (*fre)(win->_y);
  247.     (*fre)(win);
  248.     return( OK );
  249. }
  250. /***********************************************************************/
  251. int    mvwin(WINDOW *win, int y, int x)
  252. /***********************************************************************/
  253. {
  254. #ifdef PDCDEBUG
  255.     if (trace_on) PDC_debug("mvwin() - called\n");
  256. #endif
  257.  
  258.     if (win == (WINDOW *)NULL)
  259.         return( ERR );
  260.  
  261.     if (y + win->_maxy > LINES || y < 0)
  262.         return( ERR );
  263.  
  264.     if (x + win->_maxx > COLS || x < 0)
  265.         return( ERR );
  266.  
  267.     win->_begy = y;
  268.     win->_begx = x;
  269.     touchwin(win);
  270.     return( OK );
  271. }
  272. /***********************************************************************/
  273. WINDOW*    subwin(WINDOW* orig,int nlines,int ncols,int begin_y,int begin_x)
  274. /***********************************************************************/
  275. {
  276. extern    void*    (*mallc)( size_t );
  277. extern    void*    (*callc)( size_t, size_t );
  278. extern    void    (*fre)( void* );
  279.  
  280.     WINDOW*    win;
  281.     int    i;
  282.     int    j = begin_y - orig->_begy;
  283.     int    k = begin_x - orig->_begx;
  284.  
  285. #ifdef PDCDEBUG
  286.     if (trace_on) PDC_debug("subwin() - called: lines %d cols %d begy %d begx %d\n",nlines,ncols,begin_y,begin_x);
  287. #endif
  288.  
  289.     if (!orig)
  290.         return( (WINDOW *)NULL );
  291.  
  292.     /*
  293.      * make sure window fits inside the original one
  294.      */
  295.     if ((begin_y < orig->_begy) ||
  296.         (begin_x < orig->_begx) ||
  297.         (begin_y + nlines) > (orig->_begy + orig->_maxy) ||
  298.         (begin_x + ncols)  > (orig->_begx + orig->_maxx))
  299.     {
  300.         return( (WINDOW *)NULL );
  301.     }
  302.     if (!nlines)    nlines = orig->_maxy - 1 - j;
  303.     if (!ncols)    ncols  = orig->_maxx - 1 - k;
  304.     if ((win = PDC_makenew(nlines, ncols, begin_y, begin_x)) == (WINDOW *) NULL)
  305.     {
  306.         return( (WINDOW *)NULL );
  307.     }
  308.  
  309.     /*
  310.      * initialize window variables
  311.      */
  312.     win->_attrs    = orig->_attrs;
  313. /* wrs (4/10/93) -- account for window background */
  314.     win->_bkgd    = orig->_bkgd;
  315.     win->_leave    = orig->_leave;
  316.     win->_scroll    = orig->_scroll;
  317.     win->_nodelay    = orig->_nodelay;
  318.     win->_use_keypad    = orig->_use_keypad;
  319.     win->_immed    = orig->_immed;
  320.     win->_pary    = j;
  321.     win->_parx    = k;
  322.     win->_parent    = orig;
  323.  
  324.     for (i = 0; i < nlines; i++)
  325.     {
  326.         win->_y[i] = (orig->_y[j++]) + k;
  327.     }
  328.  
  329.     win->_flags |= _SUBWIN;
  330.     return (win);
  331. }
  332. /***********************************************************************/
  333. WINDOW*    derwin(WINDOW* orig,int nlines,int ncols,int begin_y,int begin_x)
  334. /***********************************************************************/
  335. {
  336.     if (orig == (WINDOW *)NULL)
  337.         return( ERR );
  338.  
  339.     return subwin(orig, nlines, ncols, begin_y+orig->_begy, begin_x+orig->_begx);
  340. }
  341. /***********************************************************************/
  342. int    mvderwin( WINDOW* win, int par_y, int par_x )
  343. /***********************************************************************/
  344. {
  345.     int i, j;
  346.     WINDOW *mypar;
  347.  
  348.     if (win == (WINDOW *)NULL)
  349.         return( ERR );
  350.  
  351.     if( win->_parent == NULL )
  352.         return( ERR );
  353.  
  354.     mypar = win->_parent;
  355.  
  356.     if( par_y < 0 || par_x < 0 ||
  357.         (par_y + win->_maxy) > mypar->_maxy ||
  358.         (par_x + win->_maxx) > mypar->_maxx )
  359.     {
  360.         return( ERR );
  361.     }
  362.  
  363.     j = par_y;
  364.     for (i = 0; i < win->_maxy; i++)
  365.     {
  366.         win->_y[i] = (mypar->_y[j++]) + par_x;
  367.     }
  368.  
  369.     win->_pary    = par_y;
  370.     win->_parx    = par_x;
  371.  
  372.     return( OK );
  373. }
  374. /***********************************************************************/
  375. WINDOW*    dupwin( WINDOW* win )
  376. /***********************************************************************/
  377. {
  378. extern    void*    (*mallc)( size_t );
  379. extern    void*    (*callc)( size_t, size_t );
  380. extern    void    (*fre)( void* );
  381.  
  382.     WINDOW* new;
  383.     chtype* ptr;
  384.     chtype* ptr1;
  385.     int nlines, ncols, begy, begx;
  386.     int    i;
  387.     int    j;
  388.  
  389.     if (!win)
  390.         return( (WINDOW *)NULL );
  391.  
  392.     nlines    = win->_maxy;
  393.     ncols    = win->_maxx;
  394.     begy    = win->_begy;
  395.     begx    = win->_begx;
  396.  
  397.     if ((new = PDC_makenew(nlines, ncols, begy, begx)) == (WINDOW *) NULL)
  398.         return( (WINDOW *)NULL );
  399.  
  400. /* copy the contents of win into new */
  401.  
  402.     for (i = 0; i < nlines; i++)
  403.     {
  404.         if ((new->_y[i] = (*callc)(ncols, sizeof(chtype))) == NULL)
  405.         {
  406.             for (j = 0; j < i; j++)
  407.             {
  408.                 /*
  409.                  * if error, free all the data
  410.                  */
  411.                 (*fre)(new->_y[j]);
  412.             }
  413.             (*fre)(new->_firstch);
  414.             (*fre)(new->_lastch);
  415.             (*fre)(new->_y);
  416.             (*fre)(new);
  417.             return( (WINDOW *)NULL );
  418.         }
  419.         else
  420.         {
  421.             for (ptr = new->_y[i], ptr1 = win->_y[i];
  422.                  ptr < new->_y[i] + ncols;)
  423.             {
  424.                 *ptr++ = *ptr1++;
  425.             }
  426.         }
  427.     }
  428.  
  429.     new->_curx = win->_curx;
  430.     new->_cury = win->_cury;
  431.     new->_maxy = win->_maxy;
  432.     new->_maxx = win->_maxx;
  433.     new->_pmaxy = win->_pmaxy;
  434.     new->_pmaxx = win->_pmaxx;
  435.     new->_begy = win->_begy;
  436.     new->_begx = win->_begx;
  437.     new->_lastpy = win->_lastpy;
  438.     new->_lastpx = win->_lastpx;
  439.     new->_lastsy1 = win->_lastsy1;
  440.     new->_lastsx1 = win->_lastsx1;
  441.     new->_lastsy2 = win->_lastsy2;
  442.     new->_lastsx2 = win->_lastsx2;
  443.     new->_flags = win->_flags;
  444.     new->_attrs = win->_attrs;
  445.     new->_tabsize = win->_tabsize;
  446.     new->_clear = win->_clear;
  447.     new->_leave = win->_leave;
  448.     new->_scroll = win->_scroll;
  449.     new->_nodelay = win->_nodelay;
  450.     new->_use_keypad = win->_use_keypad;
  451.     new->_use_idl = win->_use_idl;
  452.     new->_use_idc = win->_use_idc;
  453.     new->_tmarg = win->_tmarg;
  454.     new->_bmarg = win->_bmarg;
  455.     new->_title = win->_title;
  456.     new->_title_ofs = win->_title_ofs;
  457.     new->_title_attr = win->_title_attr;
  458.     new->_blank = win->_blank;
  459.     new->_parx = win->_parx;
  460.     new->_pary = win->_pary;
  461.     new->_parent = win->_parent;
  462.     new->_bkgd = win->_bkgd;
  463.  
  464.     for (i = 0; i < nlines; i++)
  465.     {
  466.         new->_firstch[i] = 0;
  467.         new->_lastch[i] = ncols - 1;
  468.     }
  469.  
  470.     new->_flags = win->_flags;
  471.  
  472.     return( new );
  473.  
  474. }
  475. /***********************************************************************/
  476. WINDOW*    resize_window(WINDOW *w, int lins, int cols)
  477. /***********************************************************************/
  478. {
  479. extern    void*    (*mallc)();    /* ptr to some malloc(size)    */
  480. extern    void*    (*callc)();    /* ptr to some ecalloc(num,size)*/
  481. extern    void    (*fre)();    /* ptr to some free(ptr)    */
  482.  
  483.     WINDOW*    new;
  484.     int    ncols  = max(cols, w->_pmaxx);
  485.     int    nlines = max(lins, w->_pmaxy);
  486.     int    i;
  487.     int    j;
  488.  
  489. #ifdef PDCDEBUG
  490.     if (trace_on) PDC_debug("resize_window() - called: lins %d cols %d\n",lins,cols);
  491. #endif
  492.  
  493.     if (w == (WINDOW *)NULL)
  494.         return( (WINDOW *)NULL );
  495.  
  496.     if ((lins > w->_pmaxy) || (cols > w->_pmaxx))
  497.     {
  498.         if ((new = PDC_makenew(nlines, ncols, w->_begy, w->_begx)) == (WINDOW *)NULL)
  499.             return( (WINDOW *)NULL );
  500.  
  501.         new->_curx = w->_curx;
  502.         new->_cury = w->_cury;
  503.         new->_flags = w->_flags;
  504.         new->_attrs = w->_attrs;
  505.         new->_tabsize = w->_tabsize;
  506.         new->_clear = w->_clear;
  507.         new->_leave = w->_leave;
  508.         new->_scroll = w->_scroll;
  509.         new->_nodelay = w->_nodelay;
  510.         new->_use_keypad = w->_use_keypad;
  511.         new->_tmarg = w->_tmarg;
  512.         new->_bmarg = w->_bmarg;
  513.         new->_title = w->_title;
  514.         new->_title_ofs = w->_title_ofs;
  515.         new->_title_attr = w->_title_attr;
  516.         new->_parent = w->_parent;
  517. #if 0
  518.         memcpy(new->_borderchars, w->_borderchars, 8*sizeof(chtype));
  519. #endif
  520.  
  521.         for (i = 0; i < nlines; i++)
  522.         {
  523.             /*
  524.              * make and clear the lines
  525.              */
  526.             if ((new->_y[i] = (chtype*)(*callc)(ncols, sizeof(chtype))) == NULL)
  527.             {
  528.                 for (j = 0; j < i; j++)
  529.                 {
  530.                     /*
  531.                      * if error, free all the data
  532.                      */
  533.                     (*fre)(new->_y[j]);
  534.                 }
  535.                 (*fre)(new->_firstch);
  536.                 (*fre)(new->_lastch);
  537.                 (*fre)(new->_y);
  538.                 (*fre)(new);
  539.                 return( (WINDOW *)NULL );
  540.             }
  541.         }
  542.         if ((w != curscr))
  543.         {
  544.             overwrite(w, new);
  545.             wmove(new, w->_maxy - 1, 0);
  546.             wclrtobot(new);
  547. #if 0
  548. /* JGB box uses defaults if arguments are zero, but we don't want to do
  549.    this if the window currently has no box */
  550.             if (w->_borderchars[0] || w->_borderchars[2])
  551.                 box(new, w->_borderchars[0], w->_borderchars[2]);
  552. #endif
  553.         }
  554.         delwin(w);
  555.         return( new );
  556.     }
  557.     else
  558.     {
  559.         w->_bmarg = lins - 1;
  560.         w->_maxy = lins;
  561.         w->_maxx = cols;
  562. #if 0
  563. /* JGB box uses defaults if arguments are zero, but we don't want to do
  564.    this if the window currently has no box */
  565.         if (w->_borderchars[0] || w->_borderchars[2])
  566.             box(w, w->_borderchars[0], w->_borderchars[2]);
  567. #endif
  568.         return( w );
  569.     }
  570. }
  571.